﻿#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>



//<1>逗号表达式
//int main()
//{
//	//int a = 1;
//	//int b = 2;
//	//int c = (a > b, a = b + 10, a, b = a + 1);//c=13，从左向右依次执⾏（注：都要执行），整个表达式的结果是最后⼀个表达式的结果
//	//printf("%d ", c);
//
//	//if (a = b + 1, c = a / 2, d > 0)//也都要执行，不过if语句能否进入得看最后一个表达式
//	//{
//
//	//}
//
//	//a = get_val();
//	//count_val(a);//上面和下面都重复用了同一个表达式，比较冗杂，但可以用逗号表达式改写
//	//while (a > 0)
//	//{
//	//	//业务处理
//	//	//...
//	//	a = get_val();
//	//	count_val(a);
//	//}
//
//	//如果使⽤逗号表达式，改写：
//		while (a = get_val(), count_val(a), a > 0)//进入循环前就会执行前面两个条件（改进循环外部条件）
//													//每次循环都要执行前面两个条件（改进循环内部条件）
//		{
//			//业务处理
//		}
//	return 0;
//}



//<2>下标引用操作符
//int main()
//{
//	int arr[10] = { 0 };
//	arr[5] = 6;//[] -  下标引用操作符
//	//[] 是操作符，它的操作数是：arr, 5
//	//3 + 5;
//	//
//
//	return 0;
//}



//<3>函数调用操作符
//void test()
//{
//	printf("hehe\n");
//}
//
//int Add(int x, int y)
//{
//	return x + y;
//}
//
////函数在调用的时候，函数名后边的括号就是函数调用操作符
////() - 操作数是：函数名，参数
////函数调用操作符，最少有1个操作数 - 函数名
////
//int main()
//{
//	int c = Add(2, 3);//操作数：Add，2，3
//	test();//操作数：test
//	printf("hehe");
//	printf("%d", 100);//操作数：printf，"%d"，100
//
//	return 0;
//}



//<4>结构的声明
//声明一个学生类型
//名字--字符串--字符数组
//性别--字符串（男，女，保密）--字符数组
//年龄--整数
//学号--字符串（学号较长，整型容易溢出）--字符数组
//struct student
//{
//	char name[20];//结构体成员
//	char sex[5];
//	int age;
//	char number[16];
//}s3;//分号要有，全局变量，不过只能使用一次
//
//struct stduent s2;//全局变量
//int main()
//{
//	struct student s1;//结构体变量，局部变量
//
//	return 0;
//}
	//注：结构体是能够容纳不同类型的变量，而数组只能容纳相同类型的变量




//<5>结构体变量的初始化
//struct student
//{
//	char name[20];//结构体成员
//	char sex[5];
//	int age;
//	char number[16];
//}s3 = {"wangwu","nan",17,"20251100"};//分号要有，全局变量，不过只能使用一次
//
//struct student s2 = {"lisi","nan",16,"20261100"};//全局变量
//int main()
//{
//	struct student s1 = {"zhnegsan","nan",18,"20241100"};//没有特殊声明，要按顺序进行初始化
//	struct student s1 = { .age = 18,.name = "zhangsan",.number = "20241100",.sex = "nan"};//也可以不按结构体成员的顺序进行初始化
//
//	return 0;
//}



//<6>结构体的嵌套初始化
//struct student
//{
//	char name[20];//结构体成员
//	char sex[5];
//	int age;
//	char number[16];
//	struct Point p4;//struct里面包括struct，要表示里面struct的变量，就要嵌套初始化
//}s3 = { "wangwu","nan",17,"20251100" };
//p4 = { "wangwu","nan",17,"20251100",{2,5} };//按顺序表示结构体成员的初始化内容，遇到嵌套结构体要加上大括号来表示初始化的内容
//
//struct Point
//{
//	int x;
//	int y;
//}p3 = { 2,3 };
//
//struct student s2 = { "lisi","nan",16,"20261100" };//全局变量
//
//struct Point p2 = { 3,5 };
//
//int main()
//{
//	struct student s1 = { "zhnegsan","nan",18,"20241100" };//没有特殊声明，要按顺序进行初始化
//	struct student s1 = { .age = 18,.name = "zhangsan",.number = "20241100",.sex = "nan" };//也可以不按结构体成员的顺序进行初始化
//	struct Point p1 = { 5, 3 };
//
//	return 0;
//}



//<7>结构体成员的重新输入及打印
//struct student
//{
//	char name[20];//结构体成员
//	char sex[5];
//	int age;
//	char number[16];
//}s3 = { "wangwu","nan",17,"20251100" };//分号要有，全局变量，不过只能使用一次
//
//struct student s2 = { "lisi","nan",16,"20261100" };//全局变量
//int main()
//{
//	struct student s1 = { "zhnegsan","nan",18,"20241100" };//没有特殊声明，要按顺序进行初始化
//	//struct student s1 = { .age = 18,.name = "zhangsan",.number = "20241100",.sex = "nan" };//也可以不按结构体成员的顺序进行初始化
//	scanf("%d", &(s1.age));//结构体成员的重新输入，结构体变量.结构体成员
//							//age是整型，要取地址，如果是数组就不用取地址
//	printf("%s %s %d %s", s1.name, s1.sex, s1.age, s1.number);//结构体的打印，每个占位符对应一个结构体成员，结构体变量.结构体成员
//
//	return 0;
//}



//<8>整型提升
//int main()
//{
//	//char类型是一个字节，8个比特位
//	char a = 5;
//	//原码：00000101
//	
//	char b = 125;
//	//原码：01111101
//	
//	char c = a + b;
//	//原码：00000000000000000000000000000101（整型提升）
//	//补码：00000000000000000000000000000101
//
//	//原码：00000000000000000000000001111101（整型提升）
//	//补码：00000000000000000000000001111101
//
//	//a：  00000000000000000000000000000101
//	//b：  00000000000000000000000001111101
//	//计算：00000000000000000000000010000010（补码）
//	//a+b的结果要赋给c，得先截断成8个比特，不然32个比特c存不下
//	//截断：10000010（补码）（a+b的结果赋给c，还是补码，只有观察时的打印才会用原码）
//
//	printf("%d", c);
//	//打印要用原码进行观察
//	//补码：10000010
//	//提升：11111111111111111111111110000010
//	 //原码：10000000000000000000000001111110 -->-126
//
//
//	//注：C语⾔中整型算术运算总是⾄少以缺省整型类型的精度来进⾏的
//	//注：为了获得这个精度，表达式中的字符和短整型操作数在使⽤（比如计算和打印）之前被转换为普通整型，这种转换称为整型提升
//
//	return 0;
//}



//<9>算术转换
//long double
//double
//float
//unsigned long int
//long int
//unsigned int
//int
//如果两个操作数要进行运算，但是两个操作数是不同类型，是不能进行运算的，要把其中一个数转换为另一个数的相同类型
//而要转换成哪种类型，取决于类型的优先级，上面的表格中，越往上优先级越高，当两个操作数类型不同时，采用更上面的类型



//<10>问题表达式
// 解决：
// （1）加括号
// （2）拆表达式
// 注：即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯⼀的
//	   计算路径，那这个表达式就是存在潜在⻛险的，建议不要写出特别复杂的表达式。
//注：相邻操作符优先级高的先执行，优先级低的后执行